#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

typedef float prec_t;
typedef unsigned long long int entero_t;

struct Circulo {
	entero_t r;
	entero_t d;

	Circulo( entero_t d, entero_t r ) {
		this->d = d;
		this->r = r;
	}
};

struct Intervalo {
	prec_t a, b;
	
	Intervalo( prec_t a = 0.0, prec_t b = 0.0 ) {
		this->a = a;
		this->b = b;
	}

	bool operator< ( const Intervalo &otro ) const {
		return a < otro.a;
	}
};

static int resolver( const vector< Intervalo > &intervalos, int l ) {
	int len = intervalos.size();
	int temp = 0;
	int solucion = 0;
	prec_t ultimo = 0.0;

	// Recorremos todos los intervalos: O(n)
	for ( int i = 0; i < len; i++ ) {
		if ( intervalos[i].a <= ultimo && intervalos[i].b > intervalos[temp].b ) {
			// Si el intervalo actual es mejor solución lo utilizamos.
			temp = i;
		} else if ( intervalos[i].a > ultimo && intervalos[temp].a <= ultimo ) {
			// Si no hay más intervalos disponibles, aumentamos en 1 la cantidad
			// de soluciones (correspondiente al último intervalo elegido como
			// posible solución).
			solucion++;
			
			// Si ya cubrimos toda la cancha devolvemos la cantidad de rociadores.
			if ( intervalos[temp].b >= l )
				return solucion;

			// Actualizamos el último intervalo elegido
			ultimo = intervalos[temp].b;
			temp = i;
		}
	}

	// Si llegamos al final (i = len) y el último rociador elegido era
	// parte de una solución válida, devolvemos la cantidad de soluciones
	// hasta el momento más 1 (más la correspondiente al último intervalo elegido.)
	if ( temp < len && intervalos[temp].a <= ultimo && intervalos[temp].b >= l )
		return solucion + 1;

	// No hay solución :-(
	return -1;
}

int resolverProblema( const vector< Circulo > &circulos, int l, int w ) {
	vector< Intervalo > intervalos;
	int n = circulos.size();
	
	for ( int i = 0; i < n; i++ ) {
		entero_t r = circulos[i].r;
		entero_t d = circulos[i].d;

		prec_t determinante = (r * r) - (w * w) / 4.0;
		if ( determinante <= 0.0 )
			continue;

		prec_t alcance = sqrt( determinante );
		intervalos.push_back( Intervalo( d - alcance, d + alcance ) );
	}
	
	sort( intervalos.begin(), intervalos.end() );
	return resolver( intervalos, l );
}

void resolverDesdeEntrada( istream &entrada, ostream &salida ) {
	int n, l, w;
	vector< Circulo > circulos;

	while ( entrada.good() ) {
		entrada >> n >> l >> w;

		if ( !entrada.good() )
			break;

		for ( int i = 0; i < n; i++ ) {
			entero_t r, d;
			entrada >> d >> r;
			circulos.push_back( Circulo( d, r ) );
		}
		
		int res = resolverProblema( circulos, l, w );
		circulos.clear();

		salida << res << endl;
	}
}

#ifdef ONLINE_JUDGE
int main() {
	resolverDesdeEntrada( cin, cout );
	return 0;
}
#endif